﻿using System;
using System.IO;
using System.Data;
using System.Windows;
using System.Collections;
using System.Windows.Input;
using System.ComponentModel;
using System.Windows.Controls;
using Sinacor.Infra.UI.Common;
using Sinacor.Infra.UI.Controls;
using Sinacor.Infra.UI.Controls.SmartClient;
using System.Collections.Generic;
using Sinacor.Infra.UI.Controls.SmartClient.Validation;
using Sinacor.UI.Bovespa.Ordens.View.SmartClient;
using Sinacor.UI.Bovespa.Clientes.View.SmartClient;
using System.Windows.Threading;
using System.Linq;
using Sinacor.UI.Bovespa.ManutencaoOrdens.Presenter;

namespace Sinacor.UI.Bovespa.ManutencaoOrdens.View.SmartClient
{
    public partial class ManutencaoOrdens : SinacorWindow, IManutencaoOrdens
    {
        #region Atributos

        private string _style = string.Empty;
        private Model.ChaveOrdem _parametroOrdem = null;
       
        #endregion

        #region Propriedades

        public Presenter.ManutencaoOrdens PresenterManutencaoOrdens { get; set; }

        public Model.Ordem CurrentModel
        {
            get
            {
                if (PresenterManutencaoOrdens.ModoUtilizado == Model.Enum.ModoTela.Formulario
                        && PresenterManutencaoOrdens.Estado != Model.Enum.EstadoTela.Leitura)
                    return PresenterManutencaoOrdens.OrdemAtual;
                else if (this.dtgOrdens.EditItem != null)
                    return this.dtgOrdens.EditItem as Model.Ordem;
                else if (this.dtgOrdens.Items.CurrentItem != null)
                    return this.dtgOrdens.Items.CurrentItem as Model.Ordem;
                else if (this.dtgOrdens.SelectedItem != null)
                    return this.dtgOrdens.SelectedItem as Model.Ordem;
                else if (this.dtgOrdens.SelectedIndex >= 0)
                    return this.dtgOrdens.Items[this.dtgOrdens.SelectedIndex] as Model.Ordem;
                else
                    return null;
            }
        }

        public Model.DetalheOrdem CurrentModelDetalhe
        {
            get
            {
                if (this.DtgDetalhes.EditItem != null)
                    return this.DtgDetalhes.EditItem as Model.DetalheOrdem;
                else if (this.DtgDetalhes.Items.CurrentItem != null)
                    return this.DtgDetalhes.Items.CurrentItem as Model.DetalheOrdem;
                else if (this.DtgDetalhes.SelectedItem != null)
                    return this.DtgDetalhes.SelectedItem as Model.DetalheOrdem;
                else if (this.DtgDetalhes.SelectedIndex >= 0)
                    return this.DtgDetalhes.Items[this.DtgDetalhes.SelectedIndex] as Model.DetalheOrdem;
                else
                    return null;
            }
        }

        public bool IsPreBoletoEnabled
        {
            get
            {
                bool retorno;

                if (PresenterManutencaoOrdens.OrdemAtual == null)
                {
                    retorno = false;
                }
                else
                {
                    retorno = (PresenterManutencaoOrdens.Estado != Model.Enum.EstadoTela.Inclusao
                               && PresenterManutencaoOrdens.OrdemAtual.Situacao != null
                               && PresenterManutencaoOrdens.OrdemAtual.Situacao.Value != Model.Enum.SituacaoOrdem.Cancelada
                               && PresenterManutencaoOrdens.OrdemAtual.NumeroOrdem.HasValue
                               && PresenterManutencaoOrdens.OrdemAtual.NumeroOrdem.Value != 0);
                }

                return retorno;
            }
        }

        #endregion

        #region Construtor

        /// <summary>
        /// Construtor da classe
        /// </summary>
        public ManutencaoOrdens()
        {
            InitializeComponent();
            this.Construir();
        }

        /// <summary>
        /// Construtor com ordem para ser alterada
        /// </summary>
        public ManutencaoOrdens(Model.ChaveOrdem ordem)
        {
            InitializeComponent();

            //Se recebeu uma chave ordem como parametro no construtor
            _parametroOrdem = ordem;

            this.Construir();
        }

        #endregion

        #region Eventos

        /// <summary>
        /// AfterInitialize event
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ManutencaoOrdens_AfterInitialize(object sender, RoutedEventArgs e)
        {
            //Inicializa valores
            PresenterManutencaoOrdens.Inicializar();

            //Verifica se existe informações do movimento
            if (PresenterManutencaoOrdens.InformacoesMovimento != null)
            {
                //Inicializa controles
                this.Inicializar();
            }

            //Eventos de Pesquisa
            txtSituacaoOrdemFiltro.PreviewKeyDown += new KeyEventHandler(txtSituacaoOrdemFiltro_PreviewKeyDown);
            btnCliente.Click += new RoutedEventHandler(btnCliente_Click);
            btnNovaPesquisa.Click += new RoutedEventHandler(btnNovaPesquisa_Click);
            btnPesquisarFiltro.Click += new RoutedEventHandler(btnPesquisarFiltro_Click);
            btnAtivo.Click += new RoutedEventHandler(btnAtivo_Click);

            //Eventos para o DataGrid DtgDetalhes
            this.DtgDetalhes.InsertBegun += new ItemEventHandler(dtgDetalhes_InsertBegun);
            this.DtgDetalhes.InsertEnded += new ItemEventHandler(DtgDetalhes_InsertEnded);
            this.DtgDetalhes.EndingInsert += new CancelItemEventHandler(DtgDetalhes_EndingInsert);
            this.DtgDetalhes.SelectionChanged += new SelectionChangedEventHandler(DtgDetalhes_SelectionChanged);
            this.DtgDetalhes.Deleting += new CancelItemsEventHandler(DtgDetalhes_Deleting);
            this.DtgDetalhes.Deleted += new ItemsEventHandler(DtgDetalhes_Deleted);
            this.DtgDetalhes.ApplyingStyle += new ApplyStyleHandler(DtgDetalhes_ApplyingStyle);
            this.DtgDetalhes.Inserting += new CancelItemEventHandler(DtgDetalhes_Inserting);

            //Eventos para o DataGrid dtgOrdens
            this.dtgOrdens.UpdateBegun += new ItemEventHandler(dtgOrdens_UpdateBegun);
            this.dtgOrdens.BeingUpdated += new CancelItemEventHandler(dtgOrdens_BeingUpdated);
            this.dtgOrdens.EndingUpdate += new CancelItemEventHandler(dtgOrdens_EndingUpdate);
            this.dtgOrdens.UpdateEnded += new ItemEventHandler(dtgOrdens_UpdateEnded);
            this.dtgOrdens.UpdateCanceled += new ItemEventHandler(dtgOrdens_UpdateCanceled);
            this.dtgOrdens.InsertBegun += new ItemEventHandler(dtgOrdens_InsertBegun);
            this.dtgOrdens.EndingInsert += new CancelItemEventHandler(dtgOrdens_EndingInsert);
            this.dtgOrdens.InsertEnded += new ItemEventHandler(dtgOrdens_InsertEnded);
            this.dtgOrdens.SelectionChanged += new SelectionChangedEventHandler(dtgOrdens_SelectionChanged);
            this.dtgOrdens.InsertCanceled += new ItemEventHandler(dtgOrdens_InsertCanceled);
            this.dtgOrdens.ApplyingStyle += new ApplyStyleHandler(dtgOrdens_ApplyingStyle);
            this.dtgOrdens.ContextMenuOpening += new ContextMenuEventHandler(dtgOrdens_ContextMenuOpening);
            this.dtgOrdens.ContextMenuClosing += new ContextMenuEventHandler(dtgOrdens_ContextMenuClosing);
            this.dtgOrdens.SavingAll += new CancelItemsEventHandler(dtgOrdens_SavingAll);

            //Eventos para o DataGrid DtgJustificativasHistorico
            DtgJustificativasHistorico.Undid += new ItemsEventHandler(DtgJustificativasHistorico_Undid);
            DtgJustificativasHistorico.UndidAll += new ItemsEventHandler(DtgJustificativasHistorico_UndidAll);
            DtgJustificativasHistorico.SelectionChanged += new SelectionChangedEventHandler(DtgJustificativasHistorico_SelectionChanged);
            BtnSalvarJustificativaHistorico.Click += new RoutedEventHandler(btnSalvarJustificativaHistorico_Click);

            //Eventos para o DataGrid DtgJustificativasRecente
            DtgJustificativasRecente.SelectionChanged += new SelectionChangedEventHandler(DtgJustificativasRecente_SelectionChanged);
            BtnSalvarJustificativaRecente.Click += new RoutedEventHandler(BtnSalvarJustificativaRecente_Click);

            //Evento para a aba de Financiamento POP
            btnPreBoletoFinanciamentoPOP.Click += new RoutedEventHandler(btnPreBoletoFinanciamentoPOP_Click);

            //Eventos para o formulário
            BtnFormularioAtivo.Click += new RoutedEventHandler(BtnFormularioAtivo_Click);
            BtnFormularioCliente.Click += new RoutedEventHandler(BtnFormularioCliente_Click);
            BtnFormularioPreBoleto.Click += new RoutedEventHandler(BtnFormularioPreBoleto_Click);

            CboFormularioTipoMercado.SelectionChanged += new SelectionChangedEventHandler(CboFormularioMercado_SelectionChanged);
            CboFormularioOperador.SelectionChanged += new SelectionChangedEventHandler(CboFormularioOperador_SelectionChanged);
            CboFormularioTipoOrdem.SelectionChanged += new SelectionChangedEventHandler(CboFormularioTipoOrdem_SelectionChanged);
            CboFormularioBolsa.SelectionChanged += new SelectionChangedEventHandler(CboFormularioBolsa_SelectionChanged);
            TxtFormularioApelidoCliente.LostFocus += new RoutedEventHandler(TxtFormularioApelidoCliente_LostFocus);
            TxtFormularioQuantidade.PreviewKeyDown += new KeyEventHandler(txtQuantidade_PreviewKeyDown);
            TxtFormularioAtivo.LostFocus += new RoutedEventHandler(txtAtivo_LostFocus);
            TxtFormularioQuantidade.LostFocus += new RoutedEventHandler(TxtFormularioQuantidade_LostFocus);
            BtnCancelarFormulario.Click += new RoutedEventHandler(BtnCancelarFormulario_Click);
            btnSalvarFormulario.Click += new RoutedEventHandler(btnSalvarFormulario_Click);

            //Eventos do TabControl Principal
            tabControlPrincipal.SelectionChanged += new SelectionChangedEventHandler(tabControlPrincipal_SelectionChanged);
            tabControlPrincipal.PreviewSelectionChanged += new SinacorTabControl.SinacorTabControlPreviewSelectionChangedHandler(tabControlPrincipal_PreviewSelectionChanged);

            //Se for uma chave ordem recebida no costrutor parametrizado
            if (_parametroOrdem != null)
            {
                InicializarTelaModoFormularioEdicao();
            }
        }

        /// <summary>
        /// PreviewKeyDown event - txtSituacaoOrdemFiltro
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtSituacaoOrdemFiltro_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            //Verifica teclas pressionadas
            if ((e.Key != Key.D) && (e.Key != Key.H) && (e.Key != Key.S) && (e.Key != Key.E) && (e.Key != Key.A) && (e.Key != Key.Tab) && (e.Key != Key.Back))
            {
                //Limpa campo txtSituacaoOrdemFiltro
                txtSituacaoOrdemFiltro.Text = string.Empty;
                e.Handled = true;
            }
        }

        /// <summary>
        /// Click event - btnPesquisarFiltro
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnPesquisarFiltro_Click(object sender, RoutedEventArgs e)
        {
            //Pesquisa ordens
            this.PesquisaOrdens();
        }

        /// <summary>
        /// Validating event - txtClienteOrdemFiltro
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtClienteOrdemFiltro_Validating(object sender, ValidatingEventArgs e)
        {
            ValidationResult result = ValidationResult.ValidResult;

            //Verifica se campo txtClienteOrdemFiltro está vazio
            if (e.Value != null && !string.IsNullOrEmpty(e.Value.ToString()))
            {
                //Verifica se cliente existe
                if (!this.PresenterManutencaoOrdens.ObterCliente(e.Value.ToString()))
                    result = new ValidationResult(false, "Bovespa.ManutencaoOrdens.Message.ClienteNaoCadastrado");
            }
            else
            {
                //Limpa filtro Cliente
                this.PresenterManutencaoOrdens.FiltroOrdens.Cliente = null;

                //Limpa filtro Broker
                this.PresenterManutencaoOrdens.FiltroOrdens.Broker = null;
            }

            e.Result = result;
        }

        /// <summary>
        /// Validating event - txtAtivoFiltro
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtAtivoFiltro_Validating(object sender, ValidatingEventArgs e)
        {
            ValidationResult result = ValidationResult.ValidResult;

            //Verifica se campo txtAtivoFiltro está preenchido
            if (e.Value != null && !string.IsNullOrEmpty(e.Value.ToString()))
            {
                //Verifica se ativo existe
                if (!this.PresenterManutencaoOrdens.ObterTitulo(e.Value.ToString()))
                    result = new ValidationResult(false, "Bovespa.ManutencaoOrdens.Message.AtivoNaoExiste");
            }

            e.Result = result;
        }

        /// <summary>
        /// Validating event - txtNumeroOrdemFiltro
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtNumeroOrdemFiltro_Validating(object sender, ValidatingEventArgs e)
        {
            ValidationResult result = ValidationResult.ValidResult;

            //Verifica se campo txtNumeroOrdemFiltro está preenchido
            if (e.Value != null)
            {
                //Verifica se ordem existe
                if (!this.PresenterManutencaoOrdens.VerificarExistenciaOrdem(Convert.ToInt32(e.Value)))
                    result = new ValidationResult(false, "Bovespa.ManutencaoOrdens.Message.NumeroOrdemNaoExiste");
            }

            e.Result = result;
        }

        /// <summary>
        /// Click event - btnAtivo
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnAtivo_Click(object sender, RoutedEventArgs e)
        {
            //Pesquisa Ativo
            this.PesquisarAtivo();
        }

        /// <summary>
        /// Click
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnCliente_Click(object sender, RoutedEventArgs e)
        {
            //Pesquisa cliente
            this.PesquisarCliente();
        }

        /// <summary>
        /// Click event - btnNovaPesquisa
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnNovaPesquisa_Click(object sender, RoutedEventArgs e)
        {
            //Limpa os erros gerados pelas validações feitas nos campos de pesquisa
            ValidationManager.ClearValidationErrors(txtNumeroOrdemFiltro);
            ValidationManager.ClearValidationErrors(txtAtivoFiltro);
            ValidationManager.ClearValidationErrors(txtClienteOrdemFiltro);

            //Inicializa controles
            Inicializar();
        }

        private void tabControlPrincipal_PreviewSelectionChanged(object sender, SinacorTabControlPreviewSelectionChangedEventArgs e)
        {
            if (e.SelectedTabItem != tabFinanciamentoPop
                && DtgDetalhes.IsInserting)
            {
                DtgDetalhes.EndInsert();

                if(DtgDetalhes.ContainerErrors.Count > 0)
                {
                    e.Cancel = true;
                }
            }
        }

        /// <summary>
        /// SelectionChanged event - SinacorTabControl
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void tabControlPrincipal_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (e.OriginalSource is SinacorTabControl)
            {
                if (e.RemovedItems != null
                    && e.RemovedItems.Count > 0)
                {
                    if (e.RemovedItems[0] == tabJustificativas)
                    {
                        SalvarJustificativaRecente();
                        SalvarJustificativaHistorico();

                        CboJustificativasRecente.SelectionChanged -= CboJustificativasRecente_SelectionChanged;
                        CboJustificativasHistorico.SelectionChanged -= CboJustificativasHistorico_SelectionChanged;

                        CboJustificativasRecente.IsEnabled = false;
                        CboJustificativasHistorico.IsEnabled = false;
                        TxtJustificativasRecente.IsEnabled = false;
                        TxtJustificativasHistorico.IsEnabled = false;

                        PresenterManutencaoOrdens.SincronizarJustificativas();
                    }
                }

                if (e.AddedItems != null
                    && e.AddedItems.Count > 0)
                {
                    if (e.AddedItems[0] == tabJustificativas)
                    {
                        ShowUserWaitingProcess();

                        PresenterManutencaoOrdens.CompilarJustificativas();

                        CboJustificativasRecente.SelectedIndex = -1;
                        CboJustificativasHistorico.SelectedIndex = -1;

                        CboJustificativasRecente.SelectionChanged += new SelectionChangedEventHandler(CboJustificativasRecente_SelectionChanged);
                        CboJustificativasHistorico.SelectionChanged += new SelectionChangedEventHandler(CboJustificativasHistorico_SelectionChanged);

                        HideUserWaitingProcess();
                    }

                    if (e.AddedItems[0] == tabFinanciamentoPop
                         && this.CurrentModel != null)
                    {
                        this.TratarSelecaoTabFinanciamentoPop();
                    }
                }
            }
        }

        /// <summary>
        /// PreviewKeyDown event - txtInsertQuantidade
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtQuantidade_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            SinacorDecimalTextBox campoQuantidade = (SinacorDecimalTextBox)sender;

            if (e.Key == Key.OemPeriod || e.Key == Key.AbntC2)
            {
                if (campoQuantidade.Value * 1000000 <= 99999999999.9999M)
                {
                    campoQuantidade.Value *= 1000000;

                    campoQuantidade.SelectionStart = campoQuantidade.Text.Length;
                }
            }

            if (e.Key == Key.K)
            {
                if (campoQuantidade.Value * 1000 <= 999999999999.9999M)
                {
                    campoQuantidade.Value *= 1000;
                    campoQuantidade.SelectionStart = campoQuantidade.Text.Length;
                }
            }
        }

        /// <summary>
        /// ValidaAtivo event - txtInsertAtivo
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtAtivo_ValidaAtivo(object sender, ValidatingEventArgs e)
        {
            SinacorTextBox txtAtivo = null;
            BaseRow row = null;

            if (PresenterManutencaoOrdens.ModoUtilizado == Model.Enum.ModoTela.Formulario)
            {
                txtAtivo = TxtFormularioAtivo;
            }
            else
            {
                if (dtgOrdens.IsInserting)
                    row = dtgOrdens.GetInsertionRow();
                else
                    row = dtgOrdens.GetEditRow();

                txtAtivo = (SinacorTextBox)ControlHelper.FindChild(row, "txtInsertAtivo");
            }

            if (txtAtivo != null 
                && !String.IsNullOrEmpty(txtAtivo.Text))
            {
                if (!txtAtivo.IsFocused)
                {
                    if (!this.PresenterManutencaoOrdens.ObterTitulo(txtAtivo.Text))
                    {
                        e.Result = new ValidationResult(false, "Bovespa.ManutencaoOrdens.Message.AtivoNaoExiste");
                    }
                    else
                    {
                        e.Result = ValidationResult.ValidResult;
                    }
                }
                else
                {
                    e.Result = ValidationResult.ValidResult;
                }
            }
            else
                e.Result = ValidationResult.ValidResult;
        }

        /// <summary>
        /// ValidaCliente event - txtClienteOrdem
        /// </summary>
        private void txtClienteOrdem_ValidaCliente(object sender, ValidatingEventArgs e)
        {
            SinacorTextBox txtCliente = null;
            BaseRow row = null;

            if (PresenterManutencaoOrdens.ModoUtilizado == Model.Enum.ModoTela.Formulario)
            {
                txtCliente = TxtFormularioApelidoCliente;
            }
            else
            {
                if (dtgOrdens.IsInserting)
                    row = dtgOrdens.GetInsertionRow();
                else
                    row = dtgOrdens.GetEditRow();

                txtCliente = (SinacorTextBox)ControlHelper.FindChild(row, "txtClienteOrdem");
            }

            e.Result = ValidationResult.ValidResult;

            if (txtCliente != null
                && !txtCliente.IsFocused)
            {
                if (String.IsNullOrEmpty(txtCliente.Text))
                {
                    this.PresenterManutencaoOrdens.ClienteAtual = null;
                    this.PresenterManutencaoOrdens.Emissores.Clear();
                    this.AtualizarEmissor();
                }
                else
                {
                    if (!e.Value.Equals(this.PresenterManutencaoOrdens.OrdemAtual.ApelidoCliente))
                    {
                        if (!this.PresenterManutencaoOrdens.ObterCliente(txtCliente.Text))
                            e.Result = new ValidationResult(false, "Bovespa.ManutencaoOrdens.Message.ClienteNaoCadastrado");
                        else
                        {
                            this.CurrentModel.CodigoCliente = this.PresenterManutencaoOrdens.ClienteAtual.Codigo;
                        }
                    }
                    else
                    {
                        this.PresenterManutencaoOrdens.ClienteAtual = null;
                    }
                }
            }
        }

        /// <summary>
        /// Validating event - txtInsertDigito
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtInsertDigito_Validating(object sender, ValidatingEventArgs e)
        {
            SinacorInt32TextBox txtInsertDigito = null;
            BaseRow row = null;

            if (PresenterManutencaoOrdens.ModoUtilizado == Model.Enum.ModoTela.Formulario)
            {
                txtInsertDigito = TxtFormularioDigitoCliente;
            }
            else
            {
                if (dtgOrdens.IsInserting)
                {
                    row = dtgOrdens.GetInsertionRow();
                    txtInsertDigito = (SinacorInt32TextBox)ControlHelper.FindChild(dtgOrdens.GetInsertionRow(), "txtInsertDigito");
                }
                else if (dtgOrdens.IsUpdating)
                {
                    row = dtgOrdens.GetEditRow();
                    txtInsertDigito = (SinacorInt32TextBox)ControlHelper.FindChild(dtgOrdens.GetEditRow(), "txtInsertDigito");
                }
            }

            e.Result = ValidationResult.ValidResult;

            if (txtInsertDigito != null)
            {
                if (!txtInsertDigito.IsFocused)
                {
                    if (txtInsertDigito.Value.HasValue)
                    {
                        if (!this.PresenterManutencaoOrdens.ValidarDigitoVerificador(txtInsertDigito.Value.Value))
                            e.Result = new ValidationResult(false, "Bovespa.ManutencaoOrdens.ExceptionMessage.DVClienteInvalido");
                    }
                }
            }
        }

        /// <summary>
        /// LostFocus event - txtInsertAtivo
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtAtivo_LostFocus(object sender, RoutedEventArgs e)
        {
            PresenterManutencaoOrdens.ConfigurarTitulo();
        }

        private void txtValorDolar_ValidaDolar(object sender, ValidatingEventArgs e)
        {
            if (!TxtFormularioValorDolar.IsFocused
                && TxtFormularioValorDolar.Value.HasValue
                && TxtFormularioValorDolar.Value <= 0)
            {
                e.Result = new ValidationResult(false, "Bovespa.ManutencaoOrdens.ExceptionMessage.ValorDolarInvalido");
            }
            else
            {
                e.Result = ValidationResult.ValidResult;
            }
        }

        /// <summary>
        /// ValidaQuantidade event - txtInsertQuantidade
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtQuantidade_ValidaQuantidade(object sender, ValidatingEventArgs e)
        {
            SinacorDecimalTextBox txtQuantidade = null;
            BaseRow row = null;

            if (PresenterManutencaoOrdens.ModoUtilizado == Model.Enum.ModoTela.Formulario)
            {
                txtQuantidade = TxtFormularioQuantidade;
            }
            else
            {
                if (dtgOrdens.IsInserting)
                    row = dtgOrdens.GetInsertionRow();
                else
                    row = dtgOrdens.GetEditRow();

                if (row != null)
                    txtQuantidade = (SinacorDecimalTextBox)ControlHelper.FindChild(row, "txtInsertQuantidade");
            }

            if (txtQuantidade != null 
                && !txtQuantidade.IsFocused)
            {
                if (!txtQuantidade.Value.HasValue
                    && PresenterManutencaoOrdens.ModoUtilizado == Model.Enum.ModoTela.Grade)
                {
                    e.Result = new ValidationResult(false, "Bovespa.ManutencaoOrdens.Message.QuantidadeObrigatoria");
                }
                else if (txtQuantidade.Value == 0
                         && this.CurrentModel.TipoOrdem != null
                         && this.CurrentModel.TipoOrdem.Value != Model.Enum.TipoOrdem.Financiamento)
                {
                    e.Result = new ValidationResult(false, "Bovespa.ManutencaoOrdens.ExceptionMessage.QuantidadeInvalida");
                }
                else
                {
                    e.Result = ValidationResult.ValidResult;
                }
            }
            else
            {
                e.Result = ValidationResult.ValidResult;
            }
        }

        #endregion

        #region Métodos

        /// <summary>
        /// Pesquisa cliente
        /// </summary>
        private void PesquisarCliente()
        {
            PesquisaClientes pesquisaClientes = new PesquisaClientes();

            Clientes.Model.PesquisaCliente filtroPesq = new Sinacor.UI.Bovespa.Clientes.Model.PesquisaCliente() { Apelido = txtClienteOrdemFiltro.Text };

            //Carrega paramentros
            pesquisaClientes.CarregaParametros(Sinacor.UI.Bovespa.Clientes.Model.Enum.JanelaChamada.ManutencaoOrdens, filtroPesq);

            pesquisaClientes.Owner = this;
            pesquisaClientes.SetMenuHeader("Bovespa.Ordens.Label.ManutencaoOrdens");
            pesquisaClientes.ShowDialog();

            if (pesquisaClientes.PesquisaClienteModel.Codigo > 0)
            {
                PresenterManutencaoOrdens.FiltroOrdens.ApelidoCliente = pesquisaClientes.PesquisaClienteModel.Apelido;
                txtClienteOrdemFiltro.UpdateTarget(SinacorTextBox.TextProperty);

                if (rbCliente.IsChecked.Value)
                {
                    PresenterManutencaoOrdens.FiltroOrdens.Cliente = pesquisaClientes.PesquisaClienteModel.Codigo;
                }
                else
                {
                    PresenterManutencaoOrdens.FiltroOrdens.Broker = pesquisaClientes.PesquisaClienteModel.Codigo;
                }
            }
        }

        /// <summary>
        /// Pesquisa ativo
        /// </summary>
        private void PesquisarAtivo()
        {
            Ordens.Model.Titulo modelTitulo = new Ordens.Model.Titulo();
            modelTitulo.Codigo = txtAtivoFiltro.Text;
            modelTitulo.Mercado = null;
            modelTitulo.DataPregao = ((Model.Calendario)cmbDataFiltro.SelectedItem).DataPregao;

            PesquisaTitulo pesquisaTitulo = new PesquisaTitulo();
            pesquisaTitulo.CarregarParametros(modelTitulo, null);
            pesquisaTitulo.Owner = this;
            pesquisaTitulo.SetMenuHeader("Bovespa.Ordens.Label.ManutencaoOrdens");
            pesquisaTitulo.ShowDialog();

            if (pesquisaTitulo.TituloEscolhido != null)
            {
                PresenterManutencaoOrdens.FiltroOrdens.Ativo = pesquisaTitulo.TituloEscolhido.Codigo;
                txtAtivoFiltro.UpdateTarget(SinacorTextBox.TextProperty);
            }
        }

        /// <summary>
        /// Pesquisa ordens
        /// </summary>
        private void PesquisaOrdens()
        {
            //Força o binding
            this.MoveFocus(new System.Windows.Input.TraversalRequest(FocusNavigationDirection.Next));
            this.MoveFocus(new System.Windows.Input.TraversalRequest(FocusNavigationDirection.Previous));

            HabilitarEdicaoPainel(false);

            if (rbBroker.IsChecked.Value)
            {
                PresenterManutencaoOrdens.FiltroOrdens.Broker = PresenterManutencaoOrdens.FiltroOrdens.Cliente;
                PresenterManutencaoOrdens.FiltroOrdens.Cliente = null;
            }


            if (rbCompraFiltro.IsChecked.Value)
            {
                PresenterManutencaoOrdens.FiltroOrdens.NaturezaOperacao = Model.Enum.NaturezaOperacao.Compra;
            }
            else
            {
                if (rbVendaFiltro.IsChecked.Value)
                {
                    PresenterManutencaoOrdens.FiltroOrdens.NaturezaOperacao = Model.Enum.NaturezaOperacao.Venda;
                }
                else
                {
                    PresenterManutencaoOrdens.FiltroOrdens.NaturezaOperacao = Model.Enum.NaturezaOperacao.CompraVenda;
                }
            }

            this.ConfigurarFiltroSituacaoOrdem();

            this.tabOrdens.IsSelected = true;

            this.ShowUserWaitingProcess();

            PresenterManutencaoOrdens.OrdemAtual = null;
            PresenterManutencaoOrdens.OrdensAtuais = null;

            CancelarInsercaoAlteracaoGrid();
            AtualizarOrdens();

            this.PresenterManutencaoOrdens.ConsultarOrdens();            

            this.HideUserWaitingProcess();
        }

        /// <summary>
        /// Trata a seleção da Tab FinanciamentoPop
        /// </summary>
        private void TratarSelecaoTabFinanciamentoPop()
        {
            List<Model.DetalheOrdem> detalhes = null;

            this.ShowUserWaitingProcess();

            if (this.CurrentModel.State == State.Inserted)
                this.AtualizarDetalhesOrdem();
            else
            {
                detalhes = new List<Model.DetalheOrdem>(this.CurrentModel.Detalhes);

                if (this.dtgOrdens.IsInserting ||
                    !CurrentModel.NumeroOrdem.HasValue ||
                    !CurrentModel.NumeroOrdemSubSequencia.HasValue ||
                    this.CurrentModel.Detalhes.GetChanged().Count > 0 ||
                    (detalhes != null && detalhes.Exists(x => x.State == State.Inserted)))
                {
                    this.AtualizarDetalhesOrdem();
                }
                else
                    this.PresenterManutencaoOrdens.ConsultarDetalhesOrdem();
            }

            this.HideUserWaitingProcess();
        }

        /// <summary>
        /// Inicializa controles
        /// </summary>
        private void Inicializar()
        {
            HabilitarEdicaoPainel(false);

            BtnFormularioPreBoleto.IsEnabled = false;

            this.LimparCampos(ExpanderPesquisa);

            this.rbCliente.IsChecked = true;
            this.rbCompraVendaFiltro.IsChecked = true;
            this.chkOrdensValidasFiltro.IsChecked = true;
            this.cmbDataFiltro.SelectedValue = PresenterManutencaoOrdens.InformacoesMovimento.DataMovimento.ToShortDateString();

            if (this.PresenterManutencaoOrdens.Preferencias != null)
                this.cmbOperador.SelectedValue = this.PresenterManutencaoOrdens.Preferencias.CodigoOperador;

            this.PresenterManutencaoOrdens.FiltroOrdens.Cliente = null;
            this.PresenterManutencaoOrdens.FiltroOrdens.Broker = null;

            PresenterManutencaoOrdens.OrdemAtual = null;
            PresenterManutencaoOrdens.OrdensAtuais = null;

            this.txtAtivoFiltro.Focus();
            this.txtClienteOrdemFiltro.Focus();
            this.txtNumeroOrdemFiltro.Focus();
            this.ExpanderPesquisa.Focus();
            this.DesabilitarAbaFinanciamentoPOP();

            CancelarInsercaoAlteracaoGrid();
            PresenterManutencaoOrdens.Ordens.Clear();
            PresenterManutencaoOrdens.JustificativasHistorico.Clear();
            PresenterManutencaoOrdens.JustificativasRecente.Clear();
            AtualizarOrdens();
            AtualizarJustificativas();
            
            tabJustificativas.IsEnabled = false;

            this.ClearServiceErrors();
        }

        /// <summary>
        /// Configura filtro situação ordem
        /// </summary>
        private void ConfigurarFiltroSituacaoOrdem()
        {
            string aux = this.txtSituacaoOrdemFiltro.Text;

            if (string.IsNullOrEmpty(aux))
            {
                PresenterManutencaoOrdens.FiltroOrdens.Situacao = new List<Sinacor.UI.Bovespa.ManutencaoOrdens.Model.Enum.SituacaoOrdem>();
            }
            else
            {
                PresenterManutencaoOrdens.FiltroOrdens.Situacao = new List<Sinacor.UI.Bovespa.ManutencaoOrdens.Model.Enum.SituacaoOrdem>();

                if (aux == "D")
                {
                    PresenterManutencaoOrdens.FiltroOrdens.Situacao.Add(Model.Enum.SituacaoOrdem.Cancelada);
                }

                if (aux == "H")
                {
                    PresenterManutencaoOrdens.FiltroOrdens.Situacao.Add(Model.Enum.SituacaoOrdem.HomeBroker);
                }

                if (aux == "A")
                {
                    PresenterManutencaoOrdens.FiltroOrdens.Situacao.Add(Model.Enum.SituacaoOrdem.Demais);
                }

                if (aux == "E")
                {
                    PresenterManutencaoOrdens.FiltroOrdens.Situacao.Add(Model.Enum.SituacaoOrdem.Exercicio);
                }

                if (aux == "S")
                {
                    PresenterManutencaoOrdens.FiltroOrdens.Situacao.Add(Model.Enum.SituacaoOrdem.AbertaViaSinalNegocio);
                }
            }
        }

        /// <summary>
        /// Limpar erros da model
        /// </summary>
        private void LimparErrosModel()
        {
            List<Model.Ordem> ordens = null;

            ordens = new List<Model.Ordem>(this.PresenterManutencaoOrdens.Ordens);

            foreach (Model.Ordem ordem in ordens)
            {
                ordem.ClearErrors();

                if (ordem.Justificativas != null)
                {
                    foreach (Model.Justificativa justificativa in ordem.Justificativas)
                        justificativa.ClearErrors();
                }

                if (ordem.Detalhes != null)
                {
                    foreach (Model.DetalheOrdem detalhe in ordem.Detalhes)
                        detalhe.ClearErrors();
                }
            }
        }

        /// <summary>
        /// Retorna à situação original dos campos da tela (grid e formulário)
        /// </summary>
        private void ResetarEstadoCampos()
        {
            HabilitarAlteracaoVencimentoTermo(true);
            HabilitarAlteracaoSituacao(true);
            HabilitarAlteracaoCarteira(true);
            HabilitarAlteracaoDataValidade(true);
            HabilitarAlteracaoNaturezaOperacao(true);
            HabilitarAlteracaoTipoOrdem(true);
            HabilitarAlteracaoDiscricionaria(true);
            HabilitarAlteracaoValorFinanciamento(true);
            HabilitarAlteracaoPercentualFinanciamento(true);
            HabilitarAlteracaoCliente(true);
            HabilitarAlteracaoAtivo(true);
            HabilitarAlteracaoEmissor(true);
            HabilitarAlteracaoMercado(true);
            HabilitarAlteracaoBolsa(true);
            HabilitarAlteracaoQuantidade(true);
            HabilitarAlteracaoPreco(true);
            HabilitarAlteracaoOperador(true);
            HabilitarAlteracaoQuantidadeAnexoIV(true);
            HabilitarAlteracaoQuantidadeAnexoV(true);
            HabilitarAlteracaoValorDolar(true);
            HabilitarAlteracaoDesprezaSaldo(true);
            HabilitarAlteracaoIndicadorSistemaExterno(true);
            HabilitarAlteracaoTipoLiquidacao(true);
            HabilitarAlteracaoPercentualCorretagem(true);
            HabilitarAlteracaoOrdemOriginal(true);

            ConfigurarFormularioThreeState(false);

            AtribuirAtivoObrigatorio(true);
            AtribuirClienteObrigatorio(true);
            AtribuirQuantidadeObrigatorio(true);            
            AtribuirTipoOrdemObrigatorio(true);
            AtribuirOperadorObrigatorio(true);
            AtribuirMercadoObrigatorio(true);
            AtribuirPercentualCorretagemObrigatorio(true);

            AtribuirVencimentoTermoObrigatorio(false);
            AtribuirValorFinanciamentoObrigatorio(false);
            AtribuirPercentualFinanciamentoObrigatorio(false);
            HabilitarAlteracaoCliente(true);
            HabilitarAlteracaoPercentualCorretagem(true);
            HabilitarCampoQuantidade();
            HabilitarNaturezaOperacao();
            HabilitarAtivo();

            CboFormularioMsgObservacoes.SelectionChanged -= CboFormularioMsgObservacoes_SelectionChanged;
        }

        /// <summary>
        /// Método auxiliar do construtor
        /// </summary>
        private void Construir()
        {
            PresenterManutencaoOrdens = new Sinacor.UI.Bovespa.ManutencaoOrdens.Presenter.ManutencaoOrdens(this);

            DataContext = PresenterManutencaoOrdens;

            dtgOrdens.NewItemType = typeof(Model.Ordem);
            DtgJustificativasHistorico.NewItemType = typeof(Model.Justificativa);
            DtgJustificativasRecente.NewItemType = typeof(Model.Justificativa);
            DtgDetalhes.NewItemType = typeof(Model.DetalheOrdem);

            AfterInitialize += new RoutedEventHandler(ManutencaoOrdens_AfterInitialize);
        }

        #endregion 
    }
}
